home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-2.iso / os2 / os2cl015.zip / pmwin.cpp < prev    next >
C/C++ Source or Header  |  1995-11-24  |  14KB  |  651 lines
  1. /* 
  2.  
  3.  
  4.     pmwin.cpp (emx+gcc) 
  5.  
  6.     1995 Giovanni Iachello
  7.     This is freeware software. You can use or modify it as you wish,
  8.     provided that the part of code that I wrote remains freeware.
  9.     Freeware means that the source code must be available on request 
  10.     to anyone.
  11.     You must also include this notice in all files derived from this
  12.     file.
  13.  
  14.  
  15. */
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <stdarg.h>
  20.  
  21. #include "pmwin.h"
  22. #include "pmgpi.h"
  23. #include "pmdlg.h"
  24. #include "pmhelp.h"
  25. #include "pmstdres.h"
  26.  
  27.  
  28. MRESULT PMWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  29. {
  30.     PMWin* win=NULL;
  31.  
  32.     win = (PMWin*)WinQueryWindowPtr(hwnd, 0);
  33.  
  34.     if (win) {
  35.         PMEvent event(msg,mp1,mp2,CHARMSG(&msg),MOUSEMSG(&msg));
  36.         MRESULT ret=win->msgProc(event);
  37.         if (msg==WM_DESTROY) delete win; // cancella l'oggetto se viene distrutta la finestra.
  38.         return ret;
  39.     }
  40.     return WinDefWindowProc(hwnd,msg,mp1,mp2);
  41. }
  42.  
  43.  
  44. /////////////////////////////////////////////////////////////////////////////
  45.  
  46. PMWin::PMWin(HAB iab)
  47. {
  48.     ab.PMAnchorBlock(iab);
  49.     createArgs=NULL;
  50.     hwnd=(HWND)0;
  51.     hwndFrame=(HWND)0;
  52.     oldproc=WinDefWindowProc; // per sicurezza
  53. }
  54.  
  55. PMWin::PMWin(PCSZ classname,HAB iab)
  56. {
  57.     ab.PMAnchorBlock(iab);
  58.     createArgs=new WINCREATEARGS;
  59.     hwnd=(HWND)0;
  60.     hwndFrame=(HWND)0;
  61.     oldproc=WinDefWindowProc; // per sicurezza
  62.     
  63.     createArgs->hwndParent=HWND_DESKTOP;
  64.     createArgs->flStyle= WS_VISIBLE;
  65.     createArgs->flCreateFlags=(FCF_TITLEBAR | FCF_SYSMENU |
  66.                   FCF_SIZEBORDER | FCF_MINMAX |
  67.                   FCF_SHELLPOSITION | FCF_TASKLIST);
  68.     createArgs->pszClientClass=classname;
  69.     createArgs->pszTitle=NULL;
  70.     createArgs->styleClient=0L;
  71.     createArgs->hmod=(HMODULE)0;
  72.     createArgs->idResources=0;
  73.     createArgs->phwndClient=&hwnd;
  74.  
  75.     createArgs->hab=iab;
  76.     createArgs->pszClassName=classname;
  77.     createArgs->pfnWndProc=PMWndProc;
  78.     createArgs->flClassStyle=CS_SIZEREDRAW;
  79.     createArgs->cbWindowData=sizeof(this);
  80. }
  81.  
  82. PMWin::~PMWin()
  83. {
  84.     delete createArgs;
  85. }
  86.  
  87. BOOL PMWin::createWin()
  88. {
  89.     HWND newhwnd;
  90.  
  91.     CLASSINFO temp;
  92.     if (!WinQueryClassInfo(ab,createArgs->pszClassName,&temp)) {
  93.         BOOL ret=WinRegisterClass (createArgs->hab, createArgs->pszClassName, 
  94.             createArgs->pfnWndProc,createArgs->flClassStyle, createArgs->cbWindowData);
  95.         assert(ret);
  96.     }
  97.     
  98.     oldproc=WinDefWindowProc;
  99.     
  100.     newhwnd = WinCreateStdWindow (createArgs->hwndParent,createArgs->flStyle,
  101.                 &createArgs->flCreateFlags,createArgs->pszClientClass,
  102.                 createArgs->pszTitle,createArgs->styleClient,createArgs->hmod, 
  103.                 createArgs->idResources,createArgs->phwndClient);
  104.     assert(newhwnd);
  105.     hwndFrame=newhwnd;
  106.     BOOL ret=WinSetWindowPtr(hwnd, 0, this);
  107.     assert(ret);
  108.     return hwnd;
  109. }
  110.  
  111. MRESULT PMWin::msgProc(PMEvent &event)
  112. {
  113.     event.ret=MRFROMSHORT(FALSE);
  114.     return dispachEvent(event) ? event.ret : (*oldproc)(hwnd,event.msg,event.mp1,event.mp2);
  115. }
  116.  
  117. BOOL PMWin::dispachEvent(PMEvent & event)
  118. {
  119.     if ((event.msg>=WM_MOUSEFIRST && event.msg<=WM_MOUSELAST) ||
  120.             (event.msg>=WM_EXTMOUSEFIRST && event.msg<=WM_EXTMOUSELAST) ) {
  121.         return mouse(event);
  122.     } else if (event.msg>=HM_MSG_BASE && event.msg<=HM_CONTROL) {
  123.         return helpmsg(event);
  124.     } else
  125.         switch (event.msg) {
  126.         case WM_CREATE:
  127.             return create(event);
  128.         case WM_CHAR: 
  129.             return kbd(event);
  130.         case WM_COMMAND:
  131.             return command(SHORT1FROMMP (event.mp1),SHORT2FROMMP (event.mp2));
  132.         case WM_PAINT:
  133.             return paint();
  134.         case WM_ENABLE:
  135.             return enable();
  136.         case WM_SHOW:
  137.             return show();
  138.         case WM_MOVE:
  139.             return move();
  140.         case WM_SIZE:
  141.             return size(SHORT1FROMMP (event.mp2),SHORT2FROMMP (event.mp2));
  142.         case WM_ACTIVATE:
  143.             return activate();
  144.         case WM_SETFOCUS:
  145.             return setfocus();
  146.         case WM_HELP:
  147.             return help(event);
  148.         case WM_TIMER:
  149.             return timer();
  150.         case WM_CLOSE:
  151.             return closed();
  152.         case WM_PRESPARAMCHANGED:
  153.             invalidate(TRUE);
  154.             return TRUE;
  155.         case WM_INITMENU:
  156.             PMMenu* menu=new PMMenu(HWNDFROMMP(event.mp2));
  157.             return initmenu(SHORT1FROMMP(event.mp1),menu);
  158.             delete menu;
  159.         }               
  160.     return other(event);
  161. }
  162.  
  163. BOOL PMWin::create(PMEvent &event)
  164. {
  165.     return FALSE;
  166. }
  167.  
  168. BOOL PMWin::command(USHORT id,USHORT cmddev)  // nothandled
  169. {
  170.     return FALSE;
  171. }
  172.  
  173. BOOL PMWin::paint()
  174. {
  175.     return FALSE;
  176. }
  177.  
  178. BOOL PMWin::kbd(PMEvent &event)
  179. {
  180.     return FALSE;
  181. }
  182.  
  183. BOOL PMWin::mouse(PMEvent &event)
  184. {
  185.     return FALSE;
  186. }
  187.  
  188. BOOL PMWin::enable()
  189. {
  190.     return FALSE;
  191. }
  192. BOOL PMWin::show()    
  193. {
  194.     return FALSE;
  195. }
  196. BOOL PMWin::move()
  197. {
  198.     return FALSE;
  199. }
  200. BOOL PMWin::size(SHORT,SHORT)
  201. {
  202.     return FALSE;
  203. }
  204. BOOL PMWin::activate()
  205. {
  206.     return FALSE;
  207. }
  208. BOOL PMWin::setfocus()
  209. {
  210.     return FALSE;
  211. }
  212. BOOL PMWin::help(PMEvent &)
  213. {
  214.     return FALSE;
  215. }
  216. BOOL PMWin::helpmsg(PMEvent &)
  217. {
  218.     return FALSE;
  219. }
  220.  
  221. BOOL PMWin::timer()
  222. {
  223.     return FALSE;
  224. }
  225. BOOL PMWin::closed()
  226. {
  227.     return FALSE;
  228. }
  229.  
  230. BOOL PMWin::other(PMEvent &event)
  231. {
  232.     return FALSE;
  233. }
  234.  
  235. MRESULT PMWin::close() 
  236. { 
  237.     return sendMsg(WM_CLOSE); 
  238. }
  239.  
  240. BOOL PMWin::destroyWin()
  241. {
  242.     return WinDestroyWindow(hwndFrame);
  243. }
  244.  
  245. BOOL PMWin::initmenu(SHORT id,PMMenu* menu)
  246. {
  247.     return FALSE;
  248. }
  249.  
  250.  
  251. /////////////////////////////////////////////////////////////////////////////
  252.  
  253. BOOL PMWin::ptInClient(PMPoint& pt)
  254. {
  255.     PMRect rcl;
  256.     rcl=this;
  257.     return WinPtInRect (ab, &rcl, &pt);
  258. }
  259.  
  260. /////////////////////////////////////////////////////////////////////////////
  261.  
  262. PMMessageQueue::PMMessageQueue()
  263. {
  264.     hmq=0;
  265. }
  266.  
  267. PMAnchorBlock::PMAnchorBlock()
  268. {
  269.     hab=0;
  270. }
  271.  
  272. PMAnchorBlock::~PMAnchorBlock()
  273. {
  274. }
  275.  
  276. void PMAnchorBlock::init(int flags)
  277. {
  278.     hab = WinInitialize(flags);
  279. }
  280.  
  281. void PMAnchorBlock::uninit(void)
  282. {
  283.     WinTerminate(hab);
  284. }
  285.  
  286.  
  287. PMApp::PMApp(PMAnchorBlock iab,PMMessageQueue imq,int iargc,char** iargv)
  288. {
  289.     ab=iab; 
  290.     mq=imq;
  291.     argc=iargc;
  292.     argv=iargv;
  293. }
  294.  
  295. void PMApp::quit(int ret)
  296. {
  297. }
  298.  
  299. void PMApp::run(void)
  300. {
  301.     QMSG qmsg;
  302.     while ( ab.getMsg( &qmsg ) ) 
  303.         ab.dispachMsg ( &qmsg );
  304. }
  305.  
  306. /////////////////////////////////////////////////////////////////////////////
  307.  
  308. PMMainWin::PMMainWin(PCSZ classname,HAB ab,PMHelpWin *ihelpWin) : PMWin(classname,ab) 
  309. { 
  310.     helpWin=ihelpWin;
  311.     caption=NULL;
  312.     modified=FALSE;
  313.     filename[0]='\0';
  314.     fileFlags=PMMWFF_NOTHING;
  315.     fileNone="(none)"; fileUntitled="(untitled)";
  316.     flCaption=fsCaption=fnFilter=NULL;
  317. }
  318.  
  319. // supporto per help inline (usa tutto create della classe base, e aggiunge
  320. // l'associazione automatica alla finestra di help!)
  321.  
  322. BOOL PMMainWin::createWin()
  323. {
  324.     BOOL ret;
  325.     ret=PMWin::createWin();
  326.     if (helpWin) ret&=associateHelpInstance(helpWin->getHwnd());
  327.     return ret;
  328. }
  329.  
  330. BOOL PMMainWin::destroyWin()
  331. {
  332.     BOOL ret;
  333.     if (helpWin) {
  334.         ret=associateHelpInstance(NULLHANDLE);
  335.         ret&=PMWin::destroyWin();
  336.     } else ret=PMWin::destroyWin();
  337.     return ret;
  338. }
  339.  
  340. BOOL PMMainWin::paint() 
  341. {
  342.     PMWindowPresSpace ps(this);
  343.     return paint(ps);
  344. }
  345.  
  346. BOOL PMMainWin::closed()
  347. {
  348.     if (queryEnd()) postMsg(WM_QUIT);
  349.     return TRUE;
  350. }
  351.  
  352. BOOL PMMainWin::fileKillConfirm()
  353. {
  354.     if (!modified) return TRUE;
  355.     char buf[160];
  356.     strcpy(buf,"Save Changes");
  357.     if (fileFlags==PMMWFF_FILE) {
  358.         strcat(buf," to ");
  359.         strcat(buf,filename);
  360.     }
  361.     strcat(buf,"?");
  362.     int ret=WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,(PCSZ)buf,(PCSZ)caption,0,MB_YESNOCANCEL|MB_ICONHAND|MB_APPLMODAL);
  363.     if (ret==MBID_YES) command(PMIDM_FILESAVE,0);
  364.     if (ret==MBID_CANCEL) return FALSE;
  365.     return TRUE;        
  366. }
  367.  
  368.  
  369. void PMMainWin::setTitleCaption()
  370. {
  371.     char temp[256];
  372.     if (caption==NULL) temp[0]='\0';
  373.     else {
  374.         switch (fileFlags) {
  375.         case PMMWFF_NOTHING:
  376.             sprintf(temp,"%s",caption);
  377.             break;
  378.         case PMMWFF_NONE:
  379.             if (modified)
  380.                 sprintf(temp,"%s - *%s",caption,fileNone);
  381.             else
  382.                 sprintf(temp,"%s - %s",caption,fileNone);
  383.             break;
  384.         case PMMWFF_UNTITLED:
  385.             if (modified)
  386.                 sprintf(temp,"%s - *%s",caption,fileUntitled);
  387.             else
  388.                 sprintf(temp,"%s - %s",caption,fileUntitled);
  389.             break;
  390.         case PMMWFF_FILE:
  391.             if (modified)
  392.                 sprintf(temp,"%s - *%s",caption,filename);
  393.             else
  394.                 sprintf(temp,"%s - %s",caption,filename);
  395.             break;
  396.         }
  397.     }
  398.     setFrameWindowText(temp);
  399. }
  400.  
  401. BOOL PMMainWin::command(USHORT id,USHORT cmddev)
  402. {
  403.     switch(id) {
  404.     case PMIDM_FILENEW:
  405.         if (fileKillConfirm()) {
  406.             if (fileNew()) { fileFlags=PMMWFF_UNTITLED; setModified(FALSE);    }
  407.         }
  408.         return TRUE;
  409.     case PMIDM_FILEOPEN: {
  410.         if (fileKillConfirm()) {
  411.             PMFileDialog fd(HWND_DESKTOP, hwnd, fnFilter, flCaption, "Open", FDS_OPEN_DIALOG);
  412.             int ret=fd.createWin();
  413.             if (ret==1) {
  414.                 FILEDLG fi=fd;
  415.                 if (fileOpen(fi.szFullFile)) { // se caricato cambia il filename
  416.                         strcpy(filename,fi.szFullFile);
  417.                     fileFlags=PMMWFF_FILE;
  418.                 }
  419.                 setModified(FALSE);
  420.             }
  421.         }
  422.         return TRUE;
  423.         }    
  424.     case PMIDM_FILESAVE: 
  425.         if (filename[0]) { // se c'e' filename salva con quello
  426.             fileSave(filename);
  427.             setModified(FALSE);
  428.             return TRUE;
  429.         } // altrimenti ricadi in save as
  430.     case PMIDM_FILESAVEAS: {
  431.         PMFileDialog fd(HWND_DESKTOP, hwnd, fnFilter, fsCaption, "Save", FDS_SAVEAS_DIALOG);
  432.         int ret=fd.createWin();
  433.         if (ret==1) {
  434.             FILEDLG fi=fd;
  435.             if (fileSave(fi.szFullFile)) { // se caricato cambia il filename
  436.                 strcpy(filename,fi.szFullFile);
  437.                 fileFlags=PMMWFF_FILE;
  438.             }
  439.             setModified(FALSE);
  440.         }
  441.         return TRUE;
  442.         }    
  443.     case PMIDM_FILEPRINT :
  444.         filePrint();
  445.         return TRUE;
  446.     case PMIDM_FILEEXIT :
  447.         close();
  448.         return TRUE;
  449.  
  450.     case PMIDM_EDITUNDO :
  451.         editUndo();
  452.         return TRUE;
  453.     case PMIDM_EDITREDO :
  454.         editRedo();
  455.         return TRUE;
  456.     case PMIDM_EDITCUT :
  457.         editCut();
  458.         return TRUE;
  459.     case PMIDM_EDITCOPY :
  460.         editCopy();
  461.         return TRUE;
  462.     case PMIDM_EDITPASTE:
  463.         editPaste();
  464.         return TRUE;
  465.     case PMIDM_EDITCLEAR:
  466.         editClear();
  467.         return TRUE;
  468.     case PMIDM_EDITDUPLICATE :
  469.     case PMIDM_EDITSELECTALL :
  470.         return FALSE;
  471.  
  472.     case PMIDM_HELPINDEX :
  473.         helpWin->sendMsg(HM_HELP_INDEX);
  474.         return TRUE;
  475.     case PMIDM_HELPGENERAL :
  476.         helpWin->sendMsg(HM_EXT_HELP);
  477.         return TRUE;
  478.     case PMIDM_HELPUSING :
  479.         helpWin->sendMsg(HM_DISPLAY_HELP);
  480.         return TRUE;
  481.     case PMIDM_HELPKEYS :
  482.         helpWin->sendMsg(HM_KEYS_HELP);
  483.         return TRUE;
  484.  
  485.     case PMIDM_HELPABOUT :
  486.         WinDlgBox(HWND_DESKTOP,hwnd,(PFNWP)PMDlgProc,NULLHANDLE,PMDLG_ABOUT,NULL);
  487.         return TRUE;
  488.  
  489.     }
  490.     return FALSE;
  491. }
  492.  
  493.  
  494. /////////////////////////////////////////////////////////////////////////////
  495.  
  496. static MRESULT PMSubclassWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  497. {
  498.     PMWin* win=NULL;
  499.  
  500.     win = (PMWin*)WinQueryWindowPtr(hwnd, 0);
  501.  
  502.     if (win) {
  503.         PMEvent event(msg,mp1,mp2,CHARMSG(&msg),MOUSEMSG(&msg));
  504.         MRESULT ret=win->msgProc(event);
  505.         if (msg==WM_DESTROY) delete win; // cancella l'oggetto se viene distrutta la finestra.
  506.         return ret;
  507.     }
  508.     return WinDefWindowProc(hwnd,msg,mp1,mp2);
  509. }
  510.  
  511. PMSubclassWin::PMSubclassWin(HWND hwndParent, PCSZ pszClass, PCSZ pszName,
  512.     ULONG flStyle, LONG x, LONG y, LONG cx, LONG cy, HWND hwndOwner,
  513.        HWND hwndInsertBehind, ULONG id, PVOID pCtlData, PVOID pPresParams) : PMWin(NULLHANDLE)
  514. {
  515.     createArgs=new WINCREATEARGS;
  516.     
  517.     createArgs->hwndParent=hwndParent;
  518.     createArgs->pszClientClass=pszClass;
  519.     createArgs->pszTitle=pszName;
  520.     createArgs->flStyle=flStyle;
  521.     createArgs->x=x;
  522.     createArgs->y=y;
  523.     createArgs->cx=cx;
  524.     createArgs->cy=cy;
  525.     createArgs->hwndOwner=hwndOwner;
  526.     createArgs->hwndInsertBehind=hwndInsertBehind;
  527.     createArgs->id=id;
  528.     createArgs->pCtlData=pCtlData;
  529.     createArgs->pPresParams=pPresParams;
  530.     
  531. }
  532.  
  533. PMSubclassWin::~PMSubclassWin()
  534. {
  535. //    delete createArgs;
  536. }
  537.  
  538. BOOL PMSubclassWin::createWin()
  539. {
  540.     hwnd=WinCreateWindow(createArgs->hwndParent,
  541.                         createArgs->pszClientClass,
  542.                         createArgs->pszTitle,
  543.                         createArgs->flStyle,
  544.                         createArgs->x, createArgs->y,
  545.                         createArgs->cx, createArgs->cy,
  546.                         createArgs->hwndParent,
  547.                         createArgs->hwndInsertBehind,
  548.                         createArgs->id,
  549.                         createArgs->pCtlData,
  550.                         createArgs->pPresParams);
  551.     BOOL ret=WinSetWindowPtr(hwnd, 0, this);
  552.     assert(ret);
  553.     ab.PMAnchorBlock( WinQueryAnchorBlock(hwnd) );
  554.     oldproc=WinSubclassWindow(hwnd,PMSubclassWndProc);
  555.     return hwnd;
  556. }
  557.  
  558.  
  559. /////////////////////////////////////////////////////////////////////////////
  560.  
  561. PMThread::PMThread(void* iarg,int istacksize)
  562. {
  563.     arg=iarg;
  564.     stacksize=istacksize;
  565.     id=_beginthread(threadstart,NULL,stacksize,(void*)this);
  566. }
  567.  
  568. PMThread::~PMThread()
  569. {
  570. }
  571.  
  572. void threadstart(void* arg)
  573. {
  574.     PMThread* pmt=(PMThread*)arg;
  575.     pmt->threadStore(NULL);        // annulla il puntatore
  576.  
  577.     pmt->main(pmt->arg);
  578.  
  579.     delete pmt->threadStore();     // elimina la zona di memoria del thread
  580.     delete pmt;
  581.     _endthread();
  582. }
  583.  
  584. void PMThread::threadStore(void *p)
  585. {
  586.     (*_threadstore())=p;    
  587. }
  588.  
  589. void* PMThread::threadStore()
  590. {
  591.     return *_threadstore();
  592. }
  593.  
  594. void PMThread::main(void* )
  595. {
  596. }
  597.  
  598. PMWindowThread::PMWindowThread(void* iarg,int istacksize,int iflags) : 
  599.     PMThread(iarg,istacksize), PMAnchorBlock() 
  600. {
  601.     flags=iflags;
  602.     init(flags);
  603. }
  604.  
  605. PMWindowThread::~PMWindowThread()
  606. {
  607. }
  608.  
  609. void PMWindowThread::main(void* arg)
  610. {
  611. }
  612.  
  613. /////////////////////////////////////////////////////////////////////////////
  614.  
  615. void DoAssert(PCSZ msg,PCSZ file,unsigned line)
  616. {
  617.     char buf[160];
  618.     sprintf(buf,"at line %u in file %s: \"%s\"",line,file,msg);
  619.     if (WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,buf,"ASSERTION FAILURE",0,MB_OKCANCEL|MB_ICONHAND|MB_APPLMODAL)!=MBID_OK) exit(-1);
  620. }
  621.  
  622. void ErrBox(PCSZ msg,...)
  623. {
  624.     char buf[256];
  625.  
  626.     va_list arg_ptr;
  627.     va_start(arg_ptr,msg);
  628.     vsprintf(buf,msg,arg_ptr);
  629.     va_end(arg_ptr);
  630.  
  631.     WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,msg,"Error!",0,MB_CUACRITICAL|MB_APPLMODAL);
  632. }
  633.  
  634. ULONG PMWin::msgBox(PCSZ title,PCSZ msg,...)
  635. {
  636.     char buf[256];
  637.  
  638.     va_list arg_ptr;
  639.     va_start(arg_ptr,msg);
  640.     vsprintf(buf,msg,arg_ptr);
  641.     va_end(arg_ptr);
  642.     
  643.     return WinMessageBox(HWND_DESKTOP,HWND_DESKTOP,buf,title,0,MB_OK);
  644. }
  645.  
  646. /*
  647.  * Local variables:
  648.  * compile-command: "dmake pmwin.o"
  649.  * end:
  650.  */
  651.